package com.cdp.system.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.cdp.common.core.domain.AjaxResult;
import com.cdp.common.core.domain.entity.SysFileAudit;
import com.cdp.common.core.domain.entity.SysFlyash;
import com.cdp.common.core.domain.entity.SysRegion;
import com.cdp.common.utils.uuid.IdUtils;
import com.cdp.system.dto.AuditRequestDTO;
import com.cdp.system.dto.SaveDataDTO;
import com.cdp.system.mapper.SysFlyashMapper;
import com.cdp.system.mapper.SysRegionMapper;
import com.cdp.system.mapper.sysFileAuditMapper;
import com.cdp.system.service.ISysFileAuditService;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.logging.log4j.ThreadContext;
import org.omg.CORBA.PRIVATE_MEMBER;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import javax.xml.ws.spi.WebServiceFeatureAnnotation;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.math.BigDecimal;
import java.sql.Timestamp;
import java.time.LocalDateTime;
import java.util.List;

import static cn.hutool.core.util.NumberUtil.isValidNumber;

@Service
public class SysFileAuditServiceImpl extends ServiceImpl<sysFileAuditMapper, SysFileAudit> implements ISysFileAuditService {


    @Autowired
    private sysFileAuditMapper sysFileAuditMapper;


    @Autowired
    private SysFlyashMapper sysFlyashMapper;

    @Autowired
    private SysRegionMapper sysRegionMapper;

    // 读取文件保存路径
    @Value("${file.upload-dir}")
    private String uploadDir;

    /**
     * 中间表
     * 测试用
     *
     * @return
     */
    @Override
    public List<SysFileAudit> listFileAudits() {
        List<SysFileAudit> list = list();
        return list;
    }

//  1： 水泥
//  2： 砂
//  3： 石
//  4： 粉煤灰
//  5： 减水剂
//  6： 增效剂
//  7：力学性能
//  8：变形性能
//  9：耐久性能


    /**
     * 保存到文件到服务器
     *
     * @param saveDataDTO
     * @return
     */
    @Override
    public AjaxResult processAndSaveData(SaveDataDTO saveDataDTO) {

        //校验
//        AjaxResult validationResult = validateInput(saveDataDTO);
//        if (!validationResult.isSuccess()) {
//            return validationResult;
//        }

        // 2.保存json到服务器 返回的是文件路径
        String filePath = saveDataToFile(saveDataDTO.getData(), saveDataDTO.getFileName());

        // 3. 保存文件路径和文件名称到审核表中待审核
        saveFilsJson(filePath, saveDataDTO.getTableName());

        // 4. 返回成功响应
        return AjaxResult.success("操作成功，文件已放入服务器，路径已放入数据库 " + filePath);
    }


    private String saveDataToFile(List<List<String>> data, String fileName) {
        // 生成文件名
        String filePath = uploadDir + fileName + ".json";

        // 使用 ObjectMapper 将数据转换为 JSON 格式并保存到文件中
        ObjectMapper objectMapper = new ObjectMapper();
        try (FileWriter fileWriter = new FileWriter(filePath)) {
            String jsonData = objectMapper.writeValueAsString(data);
            fileWriter.write(jsonData);
            fileWriter.flush();
        } catch (IOException e) {
            throw new RuntimeException("文件保存失败", e);
        }

        return filePath;
    }

    public void saveFilsJson(String filePath, Integer tableName) {
        // 创建 SysFileAudit 对象并设置属性
        SysFileAudit audit = new SysFileAudit();
        audit.setId(IdUtils.generateRandomNumber()); // 生成唯一 ID
        audit.setFilePath(filePath);
        audit.setTableName(tableName);
        audit.setStatus(0); // 假设 0 表示未处理状态
        // 将文件记录保存到数据库
        sysFileAuditMapper.insert(audit);
    }


    private AjaxResult validateInput(SaveDataDTO saveDataDTO) {
        // 1. 首先验证数据是否为空
        if (saveDataDTO.getData() == null || saveDataDTO.getData().isEmpty()) {
            throw new IllegalArgumentException("未检测到数据，请重新上传");
        }

        //校验之前去掉表头列
         saveDataDTO.getData().remove(0);
/**
 * 1： 水泥
 * 2： 砂
 * 3： 石
 * 4： 粉煤灰
 * 5： 减水剂
 * 6： 增效剂
 * 7：力学性能
 * 8：变形性能
 * 9：耐久性能
 */
        String targetTable;
        switch (saveDataDTO.getTableName()) {
            case 1:
                targetTable = "sys_cement";
                // 这里可以执行与 sys_cement 相关的保存操作 1： 水泥
                return checkCement(saveDataDTO.getData());

            case 2:
                targetTable = "sys_sand";
                // 这里可以执行与 sys_sand 相关的保存操作  2： 砂
                return checkSand(saveDataDTO.getData());

            case 3:
                targetTable = "sys_stone";
                // 这里可以执行与 sys_stone 相关的保存操作 3： 石
                return checkStone(saveDataDTO.getData());

            case 4:
                targetTable = "sys_flyash";
                // 对 sys_flyash 进行数据校验           4： 粉煤灰
                return checkFlyash(saveDataDTO.getData());
            // 执行完 sys_flyash 保存逻辑后直接返回，不继续执行后续操作
            case 5:
                targetTable = "sys_water_reducer";
                // 这里可以执行与 sys_water_reducer 相关的保存操作 5： 减水剂
                // checkWaterReducer(saveDataDTO.getData());
                return checkWaterReducer(saveDataDTO.getData());
            case 6:
                targetTable = "sys_efficiency_agent";
                // 这里可以执行与 sys_efficiency_agent 相关的保存操作 6： 增效剂
                return checkEfficiencyAgent(saveDataDTO.getData());
            case 7:
                targetTable = "";
                // 这里可以执行与 sys_mechanical_performance 相关的保存操作 7：力学性能
                return checkMechanicalPerformance(saveDataDTO.getData());

            case 8:
                targetTable = "";
                // 这里可以执行与 sys_deformation_performance 相关的保存操作 8：变形性能
                return checkDeformationPerformance(saveDataDTO.getData());

            case 9:
                targetTable = "";
                // 这里可以执行与 sys_durability_performance 相关的保存操作 9：耐久性能
                return checkDurabilityPerformance(saveDataDTO.getData());


            default:
                throw new IllegalArgumentException("无效的表名编号");
        }

    }


    //校验水泥表     1： 水泥
    private AjaxResult checkCement(List<List<String>> data) {

        // 校验 data 中每个元素的格式
        for (List<String> item : data) {

            if (item == null || item.size() != 5) {
                throw new IllegalArgumentException("每条数据必须包含5个元素");
            }


            // 对第一个元素进行检查是否为有效的水泥规格格式
            String level1 = item.get(0);
            if (level1 == null || level1.trim().isEmpty()) {
                return AjaxResult.error("第一个元素不应为空或仅包含空白字符");
            }
            // 正则表达式校验水泥规格格式
            String cementPattern = "^水泥P\\·O\\s*\\d+(\\.\\d{1,2})?$";
            if (!level1.matches(cementPattern)) {
                return AjaxResult.error("第一个元素应为有效的水泥规格格式（例如：水泥P·O 32.5）！");
            }





            // 对第二个元素进行检查是否为有效的数字（阿拉伯数字或带小数点）
            String level2 = item.get(1);
            if (level2 == null || level2.trim().isEmpty()) {
                return AjaxResult.error("第二个元素不应为空或仅包含空白字符");
            }

            if (!level2.matches("^-?\\d*(\\.\\d+)?$")) {
                return AjaxResult.error("第二个元素应为有效的数字（可以是阿拉伯数字或带小数点）！");
            }





            // 对第三个元素进行检查是否为有效的数字（阿拉伯数字或带小数点）
            String level3 = item.get(2);
            if (level3 == null || level3.trim().isEmpty()) {
                return AjaxResult.error("第二个元素不应为空或仅包含空白字符");
            }

            if (!level3.matches("^-?\\d*(\\.\\d+)?$")) {
                return AjaxResult.error("第三个元素应为有效的数字（可以是阿拉伯数字或带小数点）！");
            }




            // 对第四个元素进行检查是否为有效的数字（阿拉伯数字或带小数点）
            String level4 = item.get(3);
            if (level4 == null || level4.trim().isEmpty()) {
                return AjaxResult.error("第三个元素不应为空或仅包含空白字符");
            }

            if (!level4.matches("^-?\\d*(\\.\\d+)?$")) {
                return AjaxResult.error("第四个元素应为有效的数字（可以是阿拉伯数字或带小数点）！");
            }




            //校验第5个为中文
            //阿拉伯数字校验 好用
            //对类型进行检查是否为中 文文字 好用
            String chineseTextItem = item.get(4);
            if (!chineseTextItem.matches("[\\u4e00-\\u9fa5]+")) {
                return AjaxResult.error("第五个元素应为有效的中文文字");
            }



        }


        return AjaxResult.success();
    }












    // 校验 sys_stand 表的 data 格式       2： 砂
    private AjaxResult checkSand(List<List<String>> data) {
        // 校验 data 中每个元素的格式
        for (List<String> item : data) {
            if (item == null || item.size() != 3) {
                throw new IllegalArgumentException("每条数据必须包含3个元素");
            }

            //对类型进行检查是否为中 文文字 好用
            String chineseTextItem = item.get(0);
            if (!chineseTextItem.matches("[\\u4e00-\\u9fa5]+")) {
                return AjaxResult.error("第一个元素应为有效的中文文字");
            }


            String chineseTextItem2 = item.get(1);
            if (!chineseTextItem2.matches("[\\u4e00-\\u9fa5]+")) {
                return AjaxResult.error("第二个元素应为有效的中文文字");
            }
            //对类型进行检查是否为中 文文字 好用
            String chineseTextItem3 = item.get(2);
            if (!chineseTextItem3.matches("[\\u4e00-\\u9fa5]+")) {
                return AjaxResult.error("第三个元素应为有效的中文文字");
            }



        }
        return AjaxResult.success();
    }


    // 校验 sys_stone 表的 data 格式       3： 石
    private AjaxResult checkStone(List<List<String>> data) {
        // 校验 data 中每个元素的格式
        for (List<String> item : data) {
            if (item == null || item.size() != 3) {
                throw new IllegalArgumentException("每条数据必须包含三个元素");
            }


            //对类型进行检查是否为中 文文字 好用
            //第一个数字阿拉伯数字校验 好用
            String level1 = item.get(0);
            if (!level1.matches("^(?!0\\D)\\d+$")) {
                return AjaxResult.error("第一个元素应为有效的阿拉伯数字！");
            }



            // 第三个校验 对类型进行检查是否为中 文文字 好用
            String chineseTextItem = item.get(2);
            if (!chineseTextItem.matches("[\\u4e00-\\u9fa5]+")) {
                return AjaxResult.error("第三个元素应为有效的中文文字");
            }








        }

        return null;
    }


    // 校验 sys_flyash 表的 data 格式     4： 粉煤灰
    private AjaxResult checkFlyash(List<List<String>> data) {
        // 校验 data 中每个元素的格式
        for (List<String> item : data) {
            if (item == null || item.size() != 3) {
                throw new IllegalArgumentException("每条数据必须包含三个元素");

            }

            // 第一个元素应为一个非空字符串（VARCHAR 类型）
            String level = item.get(0);
            if (level == null || level.trim().isEmpty()) {
                throw new IllegalArgumentException("第一个元素应为有效的级别（非空字符串）");
            }

            // 第二个元素应为有效的 decimal(5,2) 数字（重量）
            String weight = item.get(1);
            try {
                // 尝试将第二个元素转换为 decimal(5,2)
                BigDecimal decimalWeight = new BigDecimal(weight);
                // 校验小数点后是否只有2位
                if (decimalWeight.scale() > 2) {
                    throw new IllegalArgumentException("第二个元素必须为有效的 decimal(5,2) 格式，最多两位小数");
                }
            } catch (NumberFormatException e) {
                throw new IllegalArgumentException("第二个元素必须是有效的数字，并且符合 decimal(5,2) 格式");
            }

            // 第三个元素应为非空字符串（地区名称）
            String region = item.get(2);
            if (region == null || region.trim().isEmpty()) {
                throw new IllegalArgumentException("第三个元素应为有效的地区名称（非空字符串）");
            }
        }
        return null;
    }


    //校验减水剂表                        5： 减水剂
    private AjaxResult checkWaterReducer(List<List<String>> data) {
        // 校验 data 中每个元素的格式
        for (int i = 0; i < data.size(); i++) {
            List<String> item = data.get(i);
            if (item == null || item.size() != 3) {
                return AjaxResult.error("第 " + (i + 1) + " 条数据格式错误，每条数据必须包含3个元素");
            }
        }
        return AjaxResult.success("减水剂数据校验成功");
    }


    //校验增效剂表                         6： 增效剂
    private AjaxResult checkEfficiencyAgent(List<List<String>> data) {
        return null;
    }


    //校验力学性能表                         7：力学性能
    private AjaxResult checkDurabilityPerformance(List<List<String>> data) {
        return null;
    }

    //校验变形性能性能表                         8：变形性能
    private AjaxResult checkDeformationPerformance(List<List<String>> data) {
        return null;

    }

    //校验耐久性能性能性能表                      9：耐久性能
    private AjaxResult checkMechanicalPerformance(List<List<String>> data) {
        return null;
    }






    /*----------------------------------------以下是审核接口代码---------------------------------------------*/

    /**
     * 管理员审核
     *
     * @param auditRequestDTO
     */
//    @Override
//    public AjaxResult updateAudit(AuditRequestDTO auditRequestDTO) {
//        String filePath = auditRequestDTO.getFilePath();
//        Integer tableName = auditRequestDTO.getTableName();
//        String id = auditRequestDTO.getId();
//        Integer status = auditRequestDTO.getStatus();
//        //根据id修改status的状态值
//
//        //审核通过
//        if (status == 1) {
//            //根据tableName字段确定表的名称 解析json插入数据库 插入成功之后修改状态为  1
//            String targetTable;
//            switch (tableName) {
//                case 1:
//                    targetTable = "sys_cement";
//                    break;
//                case 2:
//                    targetTable = "sys_sand";
//                    break;
//                case 3:
//                    targetTable = "sys_stone";
//                    break;
//                case 4:
//                    targetTable = "sys_flyash";
//                    saveSysFlyash(filePath, id, status);
//
//                case 5:
//                    targetTable = "sys_water_reducer";
//                    break;
//                case 6:
//                    targetTable = "sys_efficiency_agent";
//                    break;
//                default:
//                    throw new IllegalArgumentException("无效的表名编号");
//            }
//
//            // 根据id更新stusus的值
//
//            //审核不过
//        } else if (status == 2) {
//            //返回信息不做其他处理
//
//        }
//
//
//        //参数校验
//        // 确定目标表
//        //如果status==1则审核通过插入数据库
//
//
//        // 其他表处理逻辑可以在这里扩展
//
//
//        return null;
//    }
//
//    private AjaxResult saveSysFlyash(String filePath, String id, Integer status) {
//        ObjectMapper objectMapper = new ObjectMapper();
//        List<List<String>> data;
//
//        // 解析 JSON 文件
//        try {
//            File jsonFile = new File(filePath);
//            if (!jsonFile.exists()) {
//                return AjaxResult.error("文件不存在: " + filePath);
//            }
//
//            data = objectMapper.readValue(jsonFile, new com.fasterxml.jackson.core.type.TypeReference<List<List<String>>>() {});
//        } catch (IOException e) {
//            e.printStackTrace();
//            return AjaxResult.error("JSON 文件解析失败: " + e.getMessage());
//        }
//
//        // 遍历并处理每条记录
//        for (List<String> record : data) {
//            if (record.size() != 3) {
//                continue; // 跳过格式不正确的数据
//            }
//
//            String grade = record.get(0);
//            String fineness = record.get(1);
//            String regionName = record.get(2);
//
//            try {
//                // 查询 sys_region 表，检查 region_name 是否存在
//                SysRegion region = sysRegionMapper.selectOne(
//                        new QueryWrapper<SysRegion>().eq("region_name", regionName));
//
//                // 如果 region_name 不存在，插入一条新记录并获取 region_id
//                Integer regionId;
//                if (region == null) {
//                    region = new SysRegion();
//                    region.setRegionName(regionName);
//                    region.setCreateTime(Timestamp.valueOf(LocalDateTime.now()));
//                    sysRegionMapper.insert(region);
//
//                    // 获取插入记录的 region_id
//                    regionId = region.getRegionId(); // 需要在实体类中添加 `regionId` 的获取逻辑
//                } else {
//                    regionId = region.getRegionId();
//                }
//
//                // 插入粉煤灰数据
//                SysFlyash flyash = new SysFlyash();
//                flyash.setGrade(grade);
//                flyash.setFineness(new BigDecimal(fineness).doubleValue()); // 转换为 Double 类型
//                flyash.setRegionName(regionId); // 存储 region_id
//                flyash.setCreateTime(Timestamp.valueOf(LocalDateTime.now()));
//
//                int insert = sysFlyashMapper.insert(flyash);
//                if (insert > 0) {
//                    // 更新审核状态
//                    updateAuditStatus(id, status);
//                    return AjaxResult.success("审核通过并插入粉煤灰数据成功");
//                } else {
//                    System.out.println("粉煤灰数据插入失败！");
//                }
//            } catch (Exception e) {
//                e.printStackTrace();
//                System.err.println("插入数据失败: " + record);
//            }
//        }
//
//        return AjaxResult.error("没有有效数据被插入");
//    }
//
//    private void updateAuditStatus(String id, Integer status) {
//        // 创建更新对象
//        SysFileAudit fileAudit = new SysFileAudit();
//        fileAudit.setStatus(status);
//
//        // 构造条件
//        LambdaQueryWrapper<SysFileAudit> wrapper = new LambdaQueryWrapper<>();
//        wrapper.eq(SysFileAudit::getId, id);
//
//        // 执行更新操作
//        int updatedRows = sysFileAuditMapper.update(fileAudit, wrapper);
//        if (updatedRows > 0) {
//            System.out.println("审核状态更新成功, ID: " + id + ", 新状态: " + status);
//        } else {
//            System.out.println("审核状态更新失败, ID: " + id);
//        }
//    }
//


//    private AjaxResult saveSysFlyash(String filePath, String id, Integer status) {
//        ObjectMapper objectMapper = new ObjectMapper();
//        List<List<String>> data;
//        try {
//            File jsonFile = new File(filePath);
//            if (!jsonFile.exists()) {
//                throw new IOException("文件不存在: " + filePath);
//            }
//
//            // 解析 JSON 数据
//            data = objectMapper.readValue(jsonFile, new com.fasterxml.jackson.core.type.TypeReference<List<List<String>>>() {
//            });
//            System.out.println("解析数据: " + data);
//        } catch (IOException e) {
//            e.printStackTrace();
//            throw new RuntimeException("JSON 解析失败: " + e.getMessage());
//        }
//
//        // 逐条处理解析的数据
//        for (List<String> record : data) {
//            if (record.size() != 3) {
//                continue; // 数据格式不正确，跳过
//            }
//
//            String grade = record.get(0);
//            String fineness = record.get(1);
//            String regionName = record.get(2);
//
//            try {
//                // 查询 sys_region 表，检查 region_name 是否存在
//                SysRegion region = sysRegionMapper.selectOne(
//                        new QueryWrapper<SysRegion>()
//                                .eq("region_name", regionName)
//
//                );
//
//
//                    // 如果 region_name 不存在，插入一条新记录
//                    region = new SysRegion();
//                    region.setRegionName(regionName);
//                    region.setCreateTime(Timestamp.valueOf(LocalDateTime.now())); // 转换为 Date
//                    sysRegionMapper.insert(region);
//
//
//                // 插入粉煤灰数据
//                SysFlyash flyash = new SysFlyash();
//                flyash.setGrade(grade);
//                // 将 fineness 转换为 Double 类型
//                flyash.setFineness(new BigDecimal(fineness).doubleValue()); // 转换为 Double 类型
//                // 将 regionId 转换为 String 类型
//                // flyash.setRegionName(String.valueOf(regionId)); // 转换为 String 类型
//                flyash.setCreateTime(Timestamp.valueOf(LocalDateTime.now()));
//                int insert = sysFlyashMapper.insert(flyash);
//                if (insert > 0) {
//                    SysFileAudit fileAudit = new SysFileAudit();
//                    fileAudit.setStatus(status);
//                    LambdaQueryWrapper<SysFileAudit> wrapper = new LambdaQueryWrapper<>();
//                    wrapper.eq(SysFileAudit::getId, id);
//                    sysFileAuditMapper.update(fileAudit, wrapper);
//                    return AjaxResult.success("审核通过");
//
//                } else {
//                    System.out.println("插入失败！");
//                }
//
//            } catch (Exception e) {
//                e.printStackTrace();
//                System.err.println("插入数据失败: " + record);
//            }
//        }
//        return null;
//    }

    /*------------------------------------------------------------------------------*/
    @Override
    public AjaxResult updateAudit(AuditRequestDTO auditRequestDTO) {
        String filePath = auditRequestDTO.getFilePath();
        Integer tableName = auditRequestDTO.getTableName();
        String id = auditRequestDTO.getId();
        Integer status = auditRequestDTO.getStatus();

        try {
            if (status == 1) {
                // 审核通过
                String targetTable;
                switch (tableName) {
                    case 1:
                        targetTable = "sys_cement";
                        break;
                    case 2:
                        targetTable = "sys_sand";
                        break;
                    case 3:
                        targetTable = "sys_stone";
                        break;
                    case 4:
                        targetTable = "sys_flyash";
                        return saveSysFlyash(filePath, id, status); // 调用粉煤灰保存逻辑

                    case 5:
                        targetTable = "sys_water_reducer";
                        break;
                    case 6:
                        targetTable = "sys_efficiency_agent";
                        break;
                    default:
                        return AjaxResult.error("无效的表名编号: " + tableName);
                }

                // 更新审核状态为成功
                updateAuditStatus(id, status);
                return AjaxResult.success("审核通过，目标表为: " + targetTable);

            } else if (status == 2) {
                // 审核不通过处理逻辑
                updateAuditStatus(id, status);
                return AjaxResult.success("审核未通过，已更新状态");
            } else {
                return AjaxResult.error("无效的审核状态: " + status);
            }

        } catch (Exception e) {
            e.printStackTrace();
            return AjaxResult.error("审核处理失败: " + e.getMessage());
        }
    }

    private AjaxResult saveSysFlyash(String filePath, String id, Integer status) {
        ObjectMapper objectMapper = new ObjectMapper();
        List<List<String>> data;

        try {
            // 检查文件是否存在
            File jsonFile = new File(filePath);
            if (!jsonFile.exists()) {
                return AjaxResult.error("文件不存在: " + filePath);
            }

            // 解析 JSON 文件
            data = objectMapper.readValue(jsonFile, new com.fasterxml.jackson.core.type.TypeReference<List<List<String>>>() {
            });
        } catch (IOException e) {
            e.printStackTrace();
            return AjaxResult.error("JSON 文件解析失败: " + e.getMessage());
        }

        int successfulInserts = 0;

        // 遍历并处理每条记录
        for (List<String> record : data) {
            if (record.size() != 3) {
                System.err.println("无效数据格式: " + record);
                continue;
            }

            String grade = record.get(0);
            String fineness = record.get(1);
            String regionName = record.get(2);

            try {
                // 查询或插入地区信息
                SysRegion region = sysRegionMapper.selectOne(
                        new QueryWrapper<SysRegion>().eq("region_name", regionName));

                Integer regionId;
                if (region == null) {
                    region = new SysRegion();
                    region.setRegionName(regionName);
                    region.setCreateTime(Timestamp.valueOf(LocalDateTime.now()));
                    sysRegionMapper.insert(region);
                    regionId = region.getRegionId();
                } else {
                    regionId = region.getRegionId();
                }

                // 插入粉煤灰数据
                SysFlyash flyash = new SysFlyash();
                flyash.setGrade(grade);
                flyash.setFineness(BigDecimal.valueOf(Long.parseLong(fineness)));

                flyash.setRegionName(regionId);
                flyash.setCreateTime(Timestamp.valueOf(LocalDateTime.now()));

                int insert = sysFlyashMapper.insert(flyash);
                if (insert > 0) {
                    successfulInserts++;
                } else {
                    System.err.println("粉煤灰数据插入失败: " + record);
                }
            } catch (Exception e) {
                e.printStackTrace();
                System.err.println("插入数据失败: " + record);
            }
        }

        // 检查插入结果
        if (successfulInserts > 0) {
            updateAuditStatus(id, status);
            return AjaxResult.success("审核通过，插入粉煤灰数据成功，成功条数: " + successfulInserts);
        } else {
            return AjaxResult.error("没有有效数据被插入");
        }
    }

    private void updateAuditStatus(String id, Integer status) {
        SysFileAudit fileAudit = new SysFileAudit();
        fileAudit.setStatus(status);

        LambdaQueryWrapper<SysFileAudit> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SysFileAudit::getId, id);

        int updatedRows = sysFileAuditMapper.update(fileAudit, wrapper);
        if (updatedRows > 0) {
            System.out.println("审核状态更新成功, ID: " + id + ", 新状态: " + status);
        } else {
            System.err.println("审核状态更新失败, ID: " + id);
        }
    }


}